/**
 * 商品数据验证和格式化工具
 * 处理null值、数据格式问题和类型转换
 */

// 商品数据模式定义
const ProductSchema = {
  id: { type: 'number', required: true },
  name: { type: 'string', required: true, default: '未知商品' },
  description: { type: 'string', default: '暂无描述' },
  points_price: { type: 'number', required: true, default: 0 },
  original_price: { type: 'number', default: null },
  stock: { type: 'number', required: true, default: 0 },
  stock_quantity: { type: 'number', required: true, default: 0 },
  image_url: { type: 'string', default: '/static/icons/default-product.svg' },
  category: { type: 'string', required: true, default: 'other' },
  type: { type: 'string', default: null },
  is_hot: { type: 'boolean', default: false },
  is_new: { type: 'boolean', default: false },
  specifications: { type: 'object', default: null }
}

class ProductDataValidator {
  /**
   * 验证和格式化商品列表数据
   * @param {Array} products - 原始商品列表
   * @returns {Array} 格式化后的商品列表
   */
  validateProductList(products) {
    if (!Array.isArray(products)) {
      console.warn('商品列表数据格式错误，返回空数组')
      return []
    }

    return products.map((product, index) => {
      try {
        return this.validateProduct(product)
      } catch (error) {
        console.error(`商品列表第${index}项验证失败:`, error)
        return this.createDefaultProduct(product?.id || index)
      }
    }).filter(Boolean)
  }

  /**
   * 验证和格式化单个商品数据
   * @param {Object} product - 原始商品数据
   * @returns {Object} 格式化后的商品数据
   */
  validateProduct(product) {
    if (!product || typeof product !== 'object') {
      throw new Error('商品数据无效')
    }

    const validatedProduct = {}

    // 遍历模式定义，验证和格式化每个字段
    for (const [field, schema] of Object.entries(ProductSchema)) {
      try {
        validatedProduct[field] = this.validateField(product[field], schema, field)
      } catch (error) {
        console.warn(`商品字段 ${field} 验证失败:`, error.message)
        validatedProduct[field] = schema.default
      }
    }

    // 额外的业务逻辑验证
    this.validateBusinessRules(validatedProduct)

    return validatedProduct
  }

  /**
   * 验证单个字段
   * @param {*} value - 字段值
   * @param {Object} schema - 字段模式
   * @param {string} fieldName - 字段名
   * @returns {*} 验证后的值
   */
  validateField(value, schema, fieldName) {
    // 处理null和undefined
    if (value === null || value === undefined) {
      if (schema.required) {
        if (schema.default !== undefined) {
          return schema.default
        }
        throw new Error(`必需字段 ${fieldName} 不能为空`)
      }
      return schema.default
    }

    // 类型转换和验证
    switch (schema.type) {
      case 'string':
        return this.validateString(value, schema, fieldName)
      case 'number':
        return this.validateNumber(value, schema, fieldName)
      case 'boolean':
        return this.validateBoolean(value, schema, fieldName)
      case 'object':
        return this.validateObject(value, schema, fieldName)
      default:
        return value
    }
  }

  /**
   * 验证字符串类型
   */
  validateString(value, schema, fieldName) {
    if (typeof value === 'string') {
      const trimmed = value.trim()
      if (trimmed === '' && schema.default !== undefined) {
        return schema.default
      }
      return trimmed
    }

    // 尝试转换为字符串
    if (value !== null && value !== undefined) {
      return String(value).trim()
    }

    return schema.default || ''
  }

  /**
   * 验证数字类型
   */
  validateNumber(value, schema, fieldName) {
    if (typeof value === 'number' && !isNaN(value)) {
      return Math.max(0, value) // 确保非负数
    }

    // 尝试转换为数字
    const parsed = parseFloat(value)
    if (!isNaN(parsed)) {
      return Math.max(0, parsed)
    }

    if (schema.required && schema.default === undefined) {
      throw new Error(`数字字段 ${fieldName} 格式无效`)
    }

    return schema.default || 0
  }

  /**
   * 验证布尔类型
   */
  validateBoolean(value, schema, fieldName) {
    if (typeof value === 'boolean') {
      return value
    }

    // 字符串转布尔
    if (typeof value === 'string') {
      const lower = value.toLowerCase()
      if (lower === 'true' || lower === '1') return true
      if (lower === 'false' || lower === '0') return false
    }

    // 数字转布尔
    if (typeof value === 'number') {
      return value > 0
    }

    return schema.default || false
  }

  /**
   * 验证对象类型
   */
  validateObject(value, schema, fieldName) {
    if (value === null || value === undefined) {
      return schema.default
    }

    if (typeof value === 'object' && !Array.isArray(value)) {
      return value
    }

    // 尝试解析JSON字符串
    if (typeof value === 'string') {
      try {
        return JSON.parse(value)
      } catch (error) {
        console.warn(`对象字段 ${fieldName} JSON解析失败:`, error)
      }
    }

    return schema.default
  }

  /**
   * 业务规则验证
   */
  validateBusinessRules(product) {
    // 确保积分价格合理
    if (product.points_price < 0) {
      product.points_price = 0
    }

    // 确保库存数量合理
    if (product.stock_quantity < 0) {
      product.stock_quantity = 0
    }
    
    // 统一库存字段 - 支持两种字段名
    if (product.stock_quantity !== undefined && product.stock === undefined) {
      product.stock = product.stock_quantity
    } else if (product.stock !== undefined && product.stock_quantity === undefined) {
      product.stock_quantity = product.stock
    }

    // 验证图片URL格式
    if (product.image_url && !this.isValidImageUrl(product.image_url)) {
      product.image_url = '/static/icons/default-product.svg'
    }

    // 验证分类
    const validCategories = ['print', 'copy', 'binding', 'other']
    if (!validCategories.includes(product.category)) {
      product.category = 'other'
    }
  }

  /**
   * 验证图片URL是否有效
   */
  isValidImageUrl(url) {
    if (!url || typeof url !== 'string') return false
    
    // 检查是否是相对路径或绝对URL
    return url.startsWith('/') || url.startsWith('http://') || url.startsWith('https://')
  }

  /**
   * 创建默认商品数据
   */
  createDefaultProduct(id = 0) {
    const defaultProduct = {}
    
    for (const [field, schema] of Object.entries(ProductSchema)) {
      defaultProduct[field] = schema.default
    }
    
    defaultProduct.id = id
    defaultProduct.name = `商品 ${id}`
    
    return defaultProduct
  }

  /**
   * 处理API响应数据
   */
  processApiResponse(response) {
    try {
      // 检查响应格式
      if (!response || typeof response !== 'object') {
        throw new Error('API响应格式无效')
      }

      // 处理成功响应
      if (response.success) {
        if (Array.isArray(response.data)) {
          return {
            success: true,
            data: this.validateProductList(response.data)
          }
        } else if (response.data && typeof response.data === 'object') {
          // 单个商品或包含商品列表的对象
          if (response.data.products) {
            return {
              success: true,
              data: {
                ...response.data,
                products: this.validateProductList(response.data.products)
              }
            }
          } else {
            return {
              success: true,
              data: this.validateProduct(response.data)
            }
          }
        }
      }

      // 处理错误响应
      return {
        success: false,
        message: response.message || '数据处理失败',
        data: null
      }
    } catch (error) {
      console.error('API响应处理失败:', error)
      return {
        success: false,
        message: error.message || '数据处理异常',
        data: null
      }
    }
  }

  /**
   * 格式化商品显示数据
   */
  formatForDisplay(product) {
    if (!product) return null

    const validated = this.validateProduct(product)

    return {
      ...validated,
      // 格式化价格显示
      formattedPointsPrice: `${validated.points_price}积分`,
      formattedOriginalPrice: validated.original_price ? `${validated.original_price}积分` : null,
      
      // 格式化库存显示
      stockStatus: validated.stock > 0 ? `库存: ${validated.stock}` : '缺货',
      stockStatusClass: validated.stock > 0 ? 'in-stock' : 'out-of-stock',
      
      // 格式化标签
      tags: [
        validated.is_hot && '热门',
        validated.is_new && '新品'
      ].filter(Boolean),
      
      // 可用性状态
      isAvailable: validated.stock > 0,
      
      // 分类显示名称
      categoryName: this.getCategoryDisplayName(validated.category)
    }
  }

  /**
   * 获取分类显示名称
   */
  getCategoryDisplayName(category) {
    const categoryNames = {
      'print': '打印',
      'copy': '复印', 
      'binding': '装订',
      'other': '其他'
    }
    return categoryNames[category] || category
  }

  /**
   * 批量格式化商品列表用于显示
   */
  formatListForDisplay(products) {
    if (!Array.isArray(products)) return []
    
    return products.map(product => this.formatForDisplay(product)).filter(Boolean)
  }
}

// 创建单例实例
const productValidator = new ProductDataValidator()

// 导出便捷方法
export const validateProductList = (products) => productValidator.validateProductList(products)
export const validateProduct = (product) => productValidator.validateProduct(product)
export const processApiResponse = (response) => productValidator.processApiResponse(response)
export const formatForDisplay = (product) => productValidator.formatForDisplay(product)
export const formatListForDisplay = (products) => productValidator.formatListForDisplay(products)

export default productValidator